package com.htgd.gardenexpo.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Year;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

/**
 * @author ：hejing
 * @date ：Created in 2021/8/5 14:02
 * @description：时间转换工具类
 * @modified By：`
 * @version: 1.0
 */
@Slf4j
@Service
public class DateUtils {
    /**
     * 默认的日期类型
     * EEE MMM dd HH:mm:ss zzz yyyy
     */
    public static final String DEFAULT_DATE = "EEE MMM dd HH:mm:ss zzz yyyy";
    /**
     * 一般日期格式
     * yyyy-MM-dd HH:mm:ss
     */
    public static final String GENERAL_DATE = "yyyy-MM-dd HH:mm:ss";
    /**
     * 常见日期格式
     * yyyy年MM月dd日 HH时mm分ss秒
     */
    public static final String COMMON_DATE = "yyyy年MM月dd日 HH时mm分ss秒";


    /**
     * 将字符串转化为对应的日期格式的字符串
     * (若是不对应的话会报错)
     *
     * @param dateStr
     * @return
     * @throws Exception
     */
    public static String stringToString(String dateStr) throws Exception {
        String[] parts = dateStr.split("-");
        String year = parts[0];
        String month = parts[1];
        String day = parts[2];
        return year + "年" + month + "月" + day + "日";
    }

    /**
     * 将字符串转化为对应的日期格式
     * (若是不对应的话会报错)
     *
     * @param dateStr
     * @param formatStr 需要转换的时间格式
     * @return
     * @throws Exception
     */
    public static Date stringToDate(String dateStr, String formatStr) throws Exception {
        Date date = new Date();
        try {
            if (StringUtils.isEmpty(dateStr)) {
                return null;
            }
            if (StringUtils.isEmpty(formatStr)) {
                formatStr = DateUtils.GENERAL_DATE;
            }
            SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
            date = sdf.parse(dateStr);
        } catch (Exception e) {
            log.error(String.format("字符串转换指定日期错误--错误的字符串为 %s --异常为 %s",
                    dateStr, e.getMessage()));
            throw e;
        }
        return date;
    }

    /**
     * 将日期转化为相对应的字符串
     *
     * @param date
     * @param formatStr 需要转换的时间格式
     * @return
     * @throws Exception
     */
    public static String dateToStr(Date date, String formatStr) throws Exception {
        String dateStr = null;
        try {
            if (date == null) {
                return null;
            }
            //若是转换的格式为空的话，以此作为默认日期格式
            if (formatStr == null) {
                formatStr = DateUtils.GENERAL_DATE;
            }
//            SimpleDateFormat sdf = null;
//            if (isEnglish == null ? false : isEnglish) {
//                sdf = new SimpleDateFormat(formatStr, Locale.ENGLISH);
//            } else {
//                sdf = new SimpleDateFormat(formatStr);
//            }
            SimpleDateFormat sdf = new SimpleDateFormat(formatStr);

            dateStr = sdf.format(date);
        } catch (Exception e) {
            log.error(String.format("日期转化字符串错误--错误的日期为 %s --异常为 %s",
                    date, e.getMessage()));
            throw e;
        }
        return dateStr;
    }



    /**
     * 获取当天00:00:00的时间
     *
     * @return
     */
    public static Date getStartTime(Date date) {
        Calendar todayStart = Calendar.getInstance();
        todayStart.setTime(date);
        todayStart.set(Calendar.HOUR_OF_DAY, 0);
        todayStart.set(Calendar.MINUTE, 0);
        todayStart.set(Calendar.SECOND, 0);
        todayStart.set(Calendar.MILLISECOND, 0);
        return todayStart.getTime();
    }

    /**
     * 获取当天23:59:59 的时间
     *
     * @return
     */
    public static Date getEndTime(Date date) {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.setTime(date);
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime();
    }

    /**
     * 取得离现在n天的时间字符串
     *
     * @param afterDay 可往前（负数）、往后（正数）n天
     * @return 格式：yyyy-MM-dd HH:mm:ss
     */
    public static String getAfterTime(int afterDay) throws Exception {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(new Date());
        calendar.add(Calendar.DATE, afterDay);
        return dateToStr(calendar.getTime(), null);
    }

    /**
     * 比较date1是否早于date2
     *
     * @param date1
     * @param date2
     * @return
     * @throws Exception
     */
    public static boolean compareDate(Date date1, Date date2) throws Exception {
        if (date1 == null || date2 == null) {
            log.error(String.format("填入的日期不能为空"));
            throw new Exception("填入的日期不能为空");
        }
        return date1.before(date2);
    }

    /**
     * 判断时间是否在时间段内
     *
     * @param nowTime   当前时间
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return
     */
    public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime()
                || nowTime.getTime() == endTime.getTime()) {
            return true;
        }

        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);

        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);

        Calendar end = Calendar.getInstance();
        end.setTime(endTime);

        if (date.after(begin) && date.before(end)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断输入年份是否为闰年
     *
     * @param year 年份
     * @return
     */
    public static boolean leapYear(int year) {

        return year % 4 == 0 ? year % 100 == 0 ? year % 400 == 0 ? true : false : true : false;
    }

    // 根据月份获取季度
    public static int getQuarter(int month) {
        if (month >= 1 && month <= 3) {
            return 1;
        } else if (month >= 4 && month <= 6) {
            return 2;
        } else if (month >= 7 && month <= 9) {
            return 3;
        } else {
            return 4;
        }
    }

    /**
     *  获取当前周的全部
     * @param
     * @return
     */
    public static List<String> getWeekDate() {
        // 获取当前日期
        LocalDate today = LocalDate.now();

        // 获取当前周的周一日期
        LocalDate monday = today.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));

        // 获取当前周的周日日期
        LocalDate sunday = today.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));

        // 定义日期格式化器
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        // 用于存储当前周日期的列表
        List<String> weekDates = new ArrayList<>();

        // 将周一到周日的日期存入列表
        for (int i = 0; i < 7; i++) {
            // 获取周一到周日的日期并格式化
            LocalDate date = monday.plusDays(i);
            weekDates.add(date.format(formatter));  // 将日期格式化为字符串并添加到列表
        }
        return weekDates;
    }

    public static int getDayOfWeek() {
        // 获取今天的日期
        LocalDate today = LocalDate.now();

        // 获取今天是星期几（1=星期一, 7=星期日）
        int dayOfWeek = today.getDayOfWeek().getValue();

        // 将1（星期一）映射为0，7（星期日）映射为6
        return (dayOfWeek == 7) ? 6 : dayOfWeek - 1;
    }

    /**
     * 统计分析日期
     */

    public static List<String> getDateRange(String type, Integer page) {
        List<String> dateList = new ArrayList<>();

        if ("1".equals(type)) { //日

            // 获取今天的日期
            LocalDate today = LocalDate.now();

            // 每页的日期数量
            int daysPerPage = 10;

            // 计算起始日期
            LocalDate startDate = today.minusDays((page - 1) * daysPerPage);

            // 计算结束日期
            LocalDate endDate = startDate.minusDays(daysPerPage - 1); // 向前推10天

            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

            // 从startDate开始，逐日减去日期到列表
            LocalDate currentDate = startDate;
            while (!currentDate.isBefore(endDate)) {
                dateList.add(currentDate.format(formatter));
                currentDate = currentDate.minusDays(1);
            }
        } else if ("2".equals(type)) {
            // 获取今天的日期
            // 获取今天的日期
            LocalDate today = LocalDate.now();

            // 计算当前日期所在的星期几
            int dayOfWeek = today.getDayOfWeek().getValue();

            // 计算今天所在的这一周的星期一（起始日期）
            LocalDate startOfWeek = today.minusDays(dayOfWeek - 1);

            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

            // 获取过去10周的起始和结束日期
            // 根据 page 计算日期范围
            for (int i = (page - 1) * 10; i < page * 10; i++) {
                // 当前周的开始日期
                LocalDate weekStart = startOfWeek.minusWeeks(i);

                // 当前周的结束日期（周日）
                LocalDate weekEnd = weekStart.plusDays(6);

                // 格式化日期并加入列表
                dateList.add(weekStart.format(formatter) + "#" + weekEnd.format(formatter));
            }
        } else if ("3".equals(type)) { // 近十个月
            // 获取当前日期的月份
            YearMonth currentMonth = YearMonth.now();

            // 计算十个月前的月份
            YearMonth tenMonthsAgo = currentMonth.minusMonths(10);

            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");

            // 从当前月份开始，逐月减去直到十个月前
            YearMonth current = currentMonth;
            while (!current.isBefore(tenMonthsAgo)) {
                dateList.add(current.format(formatter));
                current = current.minusMonths(1);
            }
        }else if ("4".equals(type)) { // 近十年
            // 获取当前年份
            Year currentYear = Year.now();

            // 计算十年前的年份
            Year tenYearsAgo = currentYear.minusYears(10);

            // 定义日期格式
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy");

            // 从当前年份开始，逐年减去直到十年前
            Year current = currentYear;
            while (!current.isBefore(tenYearsAgo)) {
                dateList.add(current.format(formatter));
                current = current.minusYears(1);
            }
        }else {
            dateList.add("无效类型");
        }

        return dateList;
    }

    /**
     * 剧场时间转换
     */

    public static String addMinutes(String timeStr, String minutesStr) throws ParseException {
        // 定义时间格式
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");

        // 将时间字符串转换为 Date 对象
        Date time = sdf.parse(timeStr);

        // 将分钟数从字符串转换为整数
        int minutesToAdd = Integer.parseInt(minutesStr);

        // 使用 Calendar 来处理时间加法
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);

        // 增加指定的分钟数
        calendar.add(Calendar.MINUTE, minutesToAdd);

        // 返回新的时间字符串
        return sdf.format(calendar.getTime());
    }


    public static void main(String[] args) {
//         测试该方法，传入类型为 "1"
        List<String> result = getDateRange("4", 1);
        System.out.println(result);  // 示例输出: [2025-04-06, 2025-04-07, ..., 2025-04-16]

//        try {
//            String result = addMinutes("13:00", "100");
//            System.out.println(result); // 输出 14:40
//        } catch (ParseException e) {
//            e.printStackTrace();
//        }

    }
}
